// 游戏数据
const gameData = {
    coins: 1000,
    bet: 10,
    maxBet: 100,
    betStep: 10,
    isSpinning: false,
    symbols: ['🍒', '🍋', '7️⃣', '💎', '🔔', '🍉', '🃏', '🌟'],
    // 奖励倍数
    payouts: {
        '🍒': 2,  // 两个相同: 2倍
        '🍋': 4,  // 两个相同: 4倍
        '7️⃣': 10, // 两个相同: 10倍
        '💎': 15, // 两个相同: 15倍
        '🔔': 6,  // 两个相同: 6倍
        '🍉': 3,  // 两个相同: 3倍
        '🃏': 0,   // Wild符号: 替代其他符号
        '🌟': 5,   // Scatter符号: 出现即有奖励
        'jackpot': 50  // 三个777: 50倍
    },
    // 支付线定义 (每条线是3个位置，以[row, col]表示)
    payLines: [
        // 三条水平线
        [{row: 0, col: 0}, {row: 0, col: 1}, {row: 0, col: 2}], // 顶行
        [{row: 1, col: 0}, {row: 1, col: 1}, {row: 1, col: 2}], // 中行
        [{row: 2, col: 0}, {row: 2, col: 1}, {row: 2, col: 2}], // 底行
        // 对角线
        [{row: 0, col: 0}, {row: 1, col: 1}, {row: 2, col: 2}], // 左上到右下
        [{row: 2, col: 0}, {row: 1, col: 1}, {row: 0, col: 2}], // 左下到右上
        // V形线
        [{row: 0, col: 0}, {row: 1, col: 1}, {row: 0, col: 2}], // V形
        [{row: 2, col: 0}, {row: 1, col: 1}, {row: 2, col: 2}], // 倒V形
    ],
    // 游戏统计数据
    stats: {
        totalBet: 0,
        totalWin: 0,
        spinsCount: 0,
        winsCount: 0
    },
    // 三行的索引（向后兼容）
    rows: [0, 1, 2],
    // 特殊符号
    specialSymbols: {
        wild: '🃏',    // 可替代任何普通符号
        scatter: '🌟'  // 任意位置出现即有奖励
    }
};

// DOM元素
const elements = {
    coinCount: document.querySelector('.coin-count'),
    reels: document.querySelectorAll('.reel'),
    symbolsContainers: document.querySelectorAll('.symbols-container'),
    spinButton: document.querySelector('.spin-btn'),
    betAmount: document.querySelector('.bet-amount'),
    decreaseBet: document.querySelector('.decrease'),
    increaseBet: document.querySelector('.increase'),
    maxBetButton: document.querySelector('.max-bet-btn'),
    winMessage: document.querySelector('.win-message span'),
    winMessageContainer: document.querySelector('.win-message'),
    popupMessage: document.querySelector('.popup-message'),
    slotMachine: document.querySelector('.slot-machine'),
    flyingCoinsContainer: document.querySelector('.flying-coins-container'),
    
    // 菜单元素
    menuBtn: document.querySelector('.menu-btn'),
    menuDropdown: document.querySelector('.menu-dropdown'),
    helpMenuItem: document.querySelector('.help-menu-item'),
    statsMenuItem: document.querySelector('.stats-menu-item'),
    paylinesMenuItem: document.querySelector('.paylines-menu-item'),
    
    // 模态框元素
    helpModal: document.querySelector('.help-modal'),
    helpClose: document.querySelector('.help-close'),
    
    statsModal: document.querySelector('.stats-modal'),
    statsClose: document.querySelector('.stats-close'),
    
    paylinesModal: document.querySelector('.paylines-modal'),
    paylinesClose: document.querySelector('.paylines-close'),
    
    // 统计数据元素
    totalBet: document.getElementById('total-bet'),
    totalWin: document.getElementById('total-win'),
    spinsCount: document.getElementById('spins-count'),
    winsCount: document.getElementById('wins-count'),
    winRate: document.getElementById('win-rate'),
    returnRate: document.getElementById('return-rate')
};

// 初始化游戏
function initGame() {
    // 从本地存储加载数据
    loadFromLocalStorage();
    
    // 设置初始金币数
    updateCoins(gameData.coins);
    
    // 创建完整的符号列表（包括看不见的符号，用于动画）
    populateSymbols();
    
    // 更新统计信息显示
    updateStatsDisplay();
    
    // 绑定按钮事件
    bindEvents();
    
    // 确保菜单下拉列表点击不会冒泡到document
    const menuDropdown = document.querySelector('.menu-dropdown');
    if (menuDropdown) {
        menuDropdown.addEventListener('click', (e) => {
            e.stopPropagation();
        });
    }
}

// 保存数据到本地存储
function saveToLocalStorage() {
    try {
        // 保存金币数和统计数据
        const saveData = {
            coins: gameData.coins,
            stats: gameData.stats
        };
        localStorage.setItem('slotMachineData', JSON.stringify(saveData));
    } catch (error) {
        console.error('保存数据失败:', error);
    }
}

// 从本地存储加载数据
function loadFromLocalStorage() {
    try {
        const saveData = localStorage.getItem('slotMachineData');
        if (saveData) {
            const data = JSON.parse(saveData);
            
            // 恢复金币数
            if (data.coins !== undefined) {
                gameData.coins = data.coins;
            }
            
            // 恢复统计数据
            if (data.stats) {
                gameData.stats = data.stats;
            }
        }
    } catch (error) {
        console.error('加载数据失败:', error);
    }
}

// 保存统计数据
function saveStats() {
    // 更新统计显示
    updateStatsDisplay();
    
    // 保存到本地存储
    saveToLocalStorage();
}

// 更新统计显示
function updateStatsDisplay() {
    if (!elements.totalBet) return;
    
    elements.totalBet.textContent = gameData.stats.totalBet;
    elements.totalWin.textContent = gameData.stats.totalWin;
    elements.spinsCount.textContent = gameData.stats.spinsCount;
    elements.winsCount.textContent = gameData.stats.winsCount;
    
    // 计算胜率
    const winRate = gameData.stats.spinsCount > 0 
        ? (gameData.stats.winsCount / gameData.stats.spinsCount * 100).toFixed(2) 
        : '0.00';
    elements.winRate.textContent = winRate + '%';
    
    // 计算收益率
    const returnRate = gameData.stats.totalBet > 0 
        ? (gameData.stats.totalWin / gameData.stats.totalBet * 100).toFixed(2) 
        : '0.00';
    elements.returnRate.textContent = returnRate + '%';
}

// 填充符号
function populateSymbols() {
    elements.symbolsContainers.forEach(container => {
        // 清空现有内容
        container.innerHTML = '';
        
        // 生成随机符号序列（多添加几个用于动画）
        const symbolSequence = [];
        for (let i = 0; i < 15; i++) {
            const randomSymbol = gameData.symbols[Math.floor(Math.random() * gameData.symbols.length)];
            const div = document.createElement('div');
            div.className = 'symbol';
            div.textContent = randomSymbol;
            container.appendChild(div);
            symbolSequence.push(div);
        }
    });
}

// 绑定事件
function bindEvents() {
    // 点击转动按钮
    elements.spinButton.addEventListener('click', spin);
    
    // 减少下注
    elements.decreaseBet.addEventListener('click', () => {
        if (gameData.bet > gameData.betStep) {
            gameData.bet -= gameData.betStep;
            elements.betAmount.textContent = gameData.bet;
        }
    });
    
    // 增加下注
    elements.increaseBet.addEventListener('click', () => {
        if (gameData.bet < gameData.maxBet) {
            gameData.bet += gameData.betStep;
            elements.betAmount.textContent = gameData.bet;
        }
    });
    
    // 最大下注
    elements.maxBetButton.addEventListener('click', () => {
        gameData.bet = gameData.maxBet;
        elements.betAmount.textContent = gameData.bet;
    });
    
    // 菜单按钮交互 - 使用toggleMenu函数确保正确切换
    elements.menuBtn.addEventListener('click', (e) => {
        e.stopPropagation(); // 阻止事件冒泡到document
        toggleMenu(); // 使用专门的函数处理菜单切换
    });
    
    // 点击菜单项
    elements.helpMenuItem.addEventListener('click', (e) => {
        e.stopPropagation(); // 阻止事件冒泡到document
        showModal(elements.helpModal);
        // 关闭菜单
        closeMenu();
    });
    
    elements.statsMenuItem.addEventListener('click', (e) => {
        e.stopPropagation(); // 阻止事件冒泡到document
        // 在显示统计之前更新数据
        updateStatsDisplay();
        showModal(elements.statsModal);
        // 关闭菜单
        closeMenu();
    });
    
    elements.paylinesMenuItem.addEventListener('click', (e) => {
        e.stopPropagation(); // 阻止事件冒泡到document
        showModal(elements.paylinesModal);
        // 关闭菜单
        closeMenu();
    });
    
    // 绑定模态框关闭按钮
    elements.helpClose.addEventListener('click', () => {
        hideModal(elements.helpModal);
    });
    
    elements.statsClose.addEventListener('click', () => {
        hideModal(elements.statsModal);
    });
    
    elements.paylinesClose.addEventListener('click', () => {
        hideModal(elements.paylinesModal);
    });
    
    // 点击模态框外部关闭
    elements.helpModal.addEventListener('click', (e) => {
        if (e.target === elements.helpModal) {
            hideModal(elements.helpModal);
        }
    });
    
    elements.statsModal.addEventListener('click', (e) => {
        if (e.target === elements.statsModal) {
            hideModal(elements.statsModal);
        }
    });
    
    elements.paylinesModal.addEventListener('click', (e) => {
        if (e.target === elements.paylinesModal) {
            hideModal(elements.paylinesModal);
        }
    });
    
    // 点击页面其他区域关闭菜单
    const menuContainer = document.querySelector('.menu-container');
    document.addEventListener('click', (e) => {
        // 只有点击在菜单容器外部时才关闭菜单
        if (menuContainer && 
            !menuContainer.contains(e.target) && 
            elements.menuDropdown.classList.contains('active')) {
            closeMenu();
        }
    });
}

// 显示模态框
function showModal(modal) {
    // 关闭所有其他模态框
    if (elements.helpModal.classList.contains('active')) {
        elements.helpModal.classList.remove('active');
    }
    if (elements.statsModal.classList.contains('active')) {
        elements.statsModal.classList.remove('active');
    }
    if (elements.paylinesModal.classList.contains('active')) {
        elements.paylinesModal.classList.remove('active');
    }
    
    // 显示指定的模态框
    modal.classList.add('active');
}

// 隐藏模态框
function hideModal(modal) {
    modal.classList.remove('active');
}

// 关闭菜单
function closeMenu() {
    elements.menuBtn.classList.remove('active');
    elements.menuDropdown.classList.remove('active');
}

// 切换菜单
function toggleMenu() {
    // 如果菜单当前是展开的，则收起
    if (elements.menuDropdown.classList.contains('active')) {
        closeMenu();
    } else {
        // 否则展开
        elements.menuBtn.classList.add('active');
        elements.menuDropdown.classList.add('active');
    }
}


// 更新金币显示
function updateCoins(amount) {
    gameData.coins = amount;
    elements.coinCount.textContent = amount;
    
    // 保存到本地存储
    saveToLocalStorage();
}

// 转动老虎机
function spin() {
    // 如果正在旋转或金币不足，不执行操作
    if (gameData.isSpinning || gameData.coins < gameData.bet) {
        if (gameData.coins < gameData.bet) {
            showPopup('金币不足！');
        }
        return;
    }
    
    // 设置为旋转状态
    gameData.isSpinning = true;
    
    // 扣除下注金额
    updateCoins(gameData.coins - gameData.bet);
    
    // 隐藏上次的获胜信息
    hideWinMessage();
    
    // 准备每个转轮的停止位置
    const stopPositions = Array(3).fill().map(() => Math.floor(Math.random() * gameData.symbols.length));
    
    // 重新生成符号
    populateSymbols();
    
    // 开始转动动画
    spinReels(stopPositions);
}

// 执行转轮旋转动画
function spinReels(stopPositions) {
    // 按钮变灰色
    elements.spinButton.style.opacity = 0.7;
    elements.spinButton.textContent = '旋转中...';
    
    // 存储每个转轮的最终符号
    const finalSymbols = [];
    
    // 为每个转轮执行动画，错开时间
    elements.symbolsContainers.forEach((container, reelIndex) => {
        // 在各个转轮之间添加延迟
        const delay = reelIndex * 300;
        
        // 初始位置为顶部（看不见的位置）
        container.style.top = '0px';
        
        // 设置转动动画的持续时间
        const duration = 2000 + reelIndex * 500;
        
        // 延迟开始转动
        setTimeout(() => {
            // 设置转动效果
            container.style.transition = `top ${duration}ms cubic-bezier(.17,.67,.83,.67)`;
            
            // 移动到最终位置
            // 9是预设符号数量，100是每个符号的高度
            container.style.top = `-${(9 - 3) * 100}px`;
            
            // 添加一个声音效果
            playSound('spin');
            
        }, delay);
        
        // 转动结束时，重置位置并更新符号
        setTimeout(() => {
            // 获取最终显示的三个符号
            const visibleSymbols = [];
            for (let i = 0; i < 3; i++) {
                const symbolIndex = (stopPositions[reelIndex] + i) % gameData.symbols.length;
                visibleSymbols.push(gameData.symbols[symbolIndex]);
            }
            
            // 存储最终符号用于检查获胜
            finalSymbols[reelIndex] = visibleSymbols;
            
            // 如果是最后一个转轮，检查获胜
            if (reelIndex === elements.reels.length - 1) {
                // 设置一个短暂延迟让视觉效果更好
                setTimeout(() => {
                    const results = checkWin(finalSymbols);
                    processWinResults(results);
                    
                    // 重置旋转状态
                    gameData.isSpinning = false;
                    // 恢复按钮状态
                    elements.spinButton.style.opacity = 1;
                    elements.spinButton.textContent = '转动';
                }, 300);
            }
        }, duration + delay);
    });
}

// 检查是否获胜
function checkWin(reelSymbols) {
    // 创建二维数组表示整个老虎机的符号
    const allSymbols = [];
    
    // 填充符号矩阵
    for (let row = 0; row < 3; row++) {
        const rowData = [];
        for (let col = 0; col < 3; col++) {
            rowData.push(reelSymbols[col][row]);
        }
        allSymbols.push(rowData);
    }
    
    let totalWin = 0;
    const winningRows = [];
    
    // 检查Scatter符号 - 无论位置在哪里都算
    const scatterCount = countScatterSymbols(allSymbols);
    if (scatterCount >= 2) {
        // Scatter奖励
        const win = gameData.bet * gameData.payouts[gameData.specialSymbols.scatter] * scatterCount;
        totalWin += win;
        winningRows.push({
            type: 'scatter',
            count: scatterCount,
            win,
            positions: findScatterPositions(allSymbols)
        });
    }
    
    // 检查每条支付线
    gameData.payLines.forEach((payLine, lineIndex) => {
        // 获取支付线上的符号
        const lineSymbols = payLine.map(pos => allSymbols[pos.row][pos.col]);
        
        // 检查是否是大奖 (三个7)
        if (checkForJackpot(lineSymbols)) {
            // Jackpot!
            const win = gameData.bet * gameData.payouts.jackpot;
            totalWin += win;
            winningRows.push({
                line: lineIndex,
                positions: payLine,
                win,
                isJackpot: true
            });
        } 
        // 检查是否有两个或三个相同符号，考虑Wild符号
        else {
            const result = checkLineWithWild(lineSymbols);
            if (result.win > 0) {
                totalWin += result.win;
                winningRows.push({
                    line: lineIndex,
                    positions: payLine,
                    ...result
                });
            }
        }
    });
    
    // 更新游戏统计数据
    gameData.stats.totalBet += gameData.bet;
    gameData.stats.spinsCount += 1;
    
    if (totalWin > 0) {
        gameData.stats.totalWin += totalWin;
        gameData.stats.winsCount += 1;
        
        // 保存统计数据到本地存储
        saveStats();
    }
    
    return { totalWin, winningRows };
}

// 检查是否有大奖组合 (三个7)
function checkForJackpot(symbols) {
    return symbols[0] === '7️⃣' && symbols[1] === '7️⃣' && symbols[2] === '7️⃣';
}

// 计算一条支付线的奖励，考虑Wild符号替代
function checkLineWithWild(lineSymbols) {
    const wildSymbol = gameData.specialSymbols.wild;
    const wildCount = lineSymbols.filter(s => s === wildSymbol).length;
    
    // 如果全部是Wild，按最高符号算
    if (wildCount === 3) {
        const highestPayout = Math.max(...Object.values(gameData.payouts).filter(p => typeof p === 'number'));
        return {
            symbol: wildSymbol,
            count: 3,
            win: gameData.bet * highestPayout * 3,
            isJackpot: false,
            includesWild: true
        };
    }
    
    // 如果有Wild，需要找出除Wild外出现最多的符号
    if (wildCount > 0) {
        const symbolCount = {};
        lineSymbols.forEach(symbol => {
            if (symbol !== wildSymbol) {
                symbolCount[symbol] = (symbolCount[symbol] || 0) + 1;
            }
        });
        
        // 找出出现次数最多的符号
        let maxCount = 0;
        let dominantSymbol = null;
        let maxPayout = 0;
        
        Object.entries(symbolCount).forEach(([symbol, count]) => {
            const payout = gameData.payouts[symbol] || 0;
            if (count > maxCount || (count === maxCount && payout > maxPayout)) {
                maxCount = count;
                dominantSymbol = symbol;
                maxPayout = payout;
            }
        });
        
        if (dominantSymbol) {
            // 加上Wild的数量
            const totalCount = maxCount + wildCount;
            const multiplier = gameData.payouts[dominantSymbol];
            // 两个符号的基础奖励，三个符号则三倍奖励
            const finalMultiplier = totalCount === 3 ? multiplier * 3 : multiplier;
            
            return {
                symbol: dominantSymbol,
                count: totalCount,
                win: gameData.bet * finalMultiplier,
                isJackpot: false,
                includesWild: true
            };
        }
        
        return { win: 0 };
    }
    
    // 没有Wild，计算普通组合
    const symbolCount = {};
    lineSymbols.forEach(symbol => {
        symbolCount[symbol] = (symbolCount[symbol] || 0) + 1;
    });
    
    let maxWin = 0;
    let winInfo = { win: 0 };
    
    Object.entries(symbolCount).forEach(([symbol, count]) => {
        if (count >= 2 && symbol !== gameData.specialSymbols.scatter) {
            // 两个相同符号的基础奖励
            let multiplier = gameData.payouts[symbol] || 0;
            // 如果是三个相同，额外奖励
            if (count === 3) multiplier *= 3;
            
            const win = gameData.bet * multiplier;
            if (win > maxWin) {
                maxWin = win;
                winInfo = {
                    symbol,
                    count,
                    win,
                    isJackpot: false,
                    includesWild: false
                };
            }
        }
    });
    
    return winInfo;
}

// 计算Scatter符号的数量
function countScatterSymbols(allSymbols) {
    const scatterSymbol = gameData.specialSymbols.scatter;
    let count = 0;
    
    for (let row = 0; row < 3; row++) {
        for (let col = 0; col < 3; col++) {
            if (allSymbols[row][col] === scatterSymbol) {
                count++;
            }
        }
    }
    
    return count;
}

// 查找Scatter符号的位置
function findScatterPositions(allSymbols) {
    const scatterSymbol = gameData.specialSymbols.scatter;
    const positions = [];
    
    for (let row = 0; row < 3; row++) {
        for (let col = 0; col < 3; col++) {
            if (allSymbols[row][col] === scatterSymbol) {
                positions.push({ row, col });
            }
        }
    }
    
    return positions;
}
    
// 实现获胜逻辑
function processWinResults({ totalWin, winningRows }) {
    // 如果有获胜
    if (totalWin > 0) {
        // 添加中奖金额到总金币
        updateCoins(gameData.coins + totalWin);
        
        // 显示获胜信息
        showWin(totalWin, winningRows);
        
        // 播放获胜声音
        playSound('win');
    } else {
        // 播放失败声音
        playSound('lose');
    }
}

// 显示获胜信息和动画
function showWin(amount, winningRows) {
    // 使用拟态框显示获奖信息
    showPopup(`恭喜！赢得 ${amount} 金币！`);
    
    // 处理不同类型的获胜
    winningRows.forEach(win => {
        if (win.type === 'scatter') {
            // 高亮所有Scatter符号
            win.positions.forEach(pos => {
                const symbolElement = getSymbolElement(pos.row, pos.col);
                highlightSymbol(symbolElement);
            });
        } else if (win.isJackpot) {
            // 高亮所有获胜线上的符号
            win.positions.forEach(pos => {
                const symbolElement = getSymbolElement(pos.row, pos.col);
                highlightSymbol(symbolElement);
            });
            
            // 添加大奖效果
            showPopup('恭喜获得大奖！');
            
            // 添加震动效果
            elements.slotMachine.classList.add('shake');
            setTimeout(() => {
                elements.slotMachine.classList.remove('shake');
            }, 500);
        } else {
            // 高亮普通获胜线
            win.positions.forEach(pos => {
                const symbolElement = getSymbolElement(pos.row, pos.col);
                highlightSymbol(symbolElement);
            });
        }
    });
    
    // 添加闪光效果
    elements.slotMachine.classList.add('shine');
    setTimeout(() => {
        elements.slotMachine.classList.remove('shine');
    }, 1500);
    
    // 创建金币飞行动画
    createFlyingCoins(amount);
}

// 获取特定位置的符号元素
function getSymbolElement(row, col) {
    // 获取对应转轮(列)的符号容器
    const container = elements.symbolsContainers[col];
    // 计算符号的实际索引 (每个转轮有多个符号)
    const symbolIndex = 9 + row; // 基础偏移 + 行索引
    return container.children[symbolIndex];
}

// 高亮符号元素
function highlightSymbol(element) {
    // 添加高亮动画
    element.classList.add('highlight');
    setTimeout(() => {
        element.classList.remove('highlight');
    }, 2000);
}

// 隐藏获胜信息
function hideWinMessage() {
    elements.winMessageContainer.classList.remove('active');
}

// 显示弹出消息
function showPopup(message) {
    // 获取弹出消息元素 - 防止页面加载时还未定义elements
    const popupEl = elements?.popupMessage || document.querySelector('.popup-message');
    if (!popupEl) return;
    
    // 清除任何可能存在的旧定时器
    if (window.popupTimer) {
        clearTimeout(window.popupTimer);
        popupEl.classList.remove('active');
    }
    
    // 设置新消息并显示
    popupEl.textContent = message;
    popupEl.style.animation = 'none'; // 重置动画
    
    // 强制重绘
    void popupEl.offsetWidth;
    
    // 添加激活类
    popupEl.classList.add('active');
    
    // 1.5秒后移除活动类(更短的显示时间)
    window.popupTimer = setTimeout(() => {
        popupEl.classList.remove('active');
    }, 1500);
}

// 创建飞行的金币动画
function createFlyingCoins(amount) {
    // 金币数量基于赢得的金额，但有上限
    const coinCount = Math.min(Math.floor(amount / 10), 30);
    
    // 获取目标位置 (金币显示区)
    const targetRect = elements.coinCount.getBoundingClientRect();
    const targetX = targetRect.left + targetRect.width / 2;
    const targetY = targetRect.top + targetRect.height / 2;
    
    // 创建并动画每个金币
    for (let i = 0; i < coinCount; i++) {
        setTimeout(() => {
            // 创建金币元素
            const coin = document.createElement('div');
            coin.className = 'flying-coin';
            coin.textContent = '🪙';
            
            // 设置随机起始位置 (从老虎机区域)
            const slotRect = elements.slotMachine.getBoundingClientRect();
            const startX = slotRect.left + Math.random() * slotRect.width;
            const startY = slotRect.top + Math.random() * slotRect.height;
            
            // 放置金币
            coin.style.left = `${startX}px`;
            coin.style.top = `${startY}px`;
            
            // 添加到容器
            elements.flyingCoinsContainer.appendChild(coin);
            
            // 设置目标位置的动画
            setTimeout(() => {
                // 贝塞尔曲线路径动画
                coin.style.transition = 'all 1s cubic-bezier(.17,.67,.83,.67)';
                coin.style.left = `${targetX}px`;
                coin.style.top = `${targetY}px`;
                coin.style.transform = 'scale(0.2)';
                coin.style.opacity = '0';
                
                // 移除金币元素
                setTimeout(() => {
                    if (coin.parentNode) {
                        coin.parentNode.removeChild(coin);
                    }
                }, 1000);
            }, 10);
        }, i * 100); // 错开每个金币的开始时间
    }
}

// 播放声音效果（实际使用需要添加声音文件）
function playSound(type) {
    // 这里可以实现声音播放功能
    // 例如：
    /*
    const audio = new Audio();
    switch(type) {
        case 'spin':
            audio.src = 'sounds/spin.mp3';
            break;
        case 'win':
            audio.src = 'sounds/win.mp3';
            break;
        case 'lose':
            audio.src = 'sounds/lose.mp3';
            break;
    }
    audio.play();
    */
}

// 处理页面加载
document.addEventListener('DOMContentLoaded', () => {
    console.log('DOM加载完成');
    
    // 显示加载屏幕和容器
    const loadingScreen = document.querySelector('.loading-screen');
    const container = document.querySelector('.container');
    const popupMessage = document.querySelector('.popup-message');
    
    // 确保游戏容器初始隐藏
    if (container) {
        container.style.display = 'none';
    }
    
    // 预加载所有资源后初始化游戏
    setTimeout(() => {
        console.log('开始显示游戏');
        
        // 隐藏加载屏幕，显示游戏容器
        if (loadingScreen) {
            loadingScreen.classList.add('hidden');
        }
        
        if (container) {
            container.style.display = 'flex';
        }
        
        // 初始化游戏
        initGame();
        
        // 显示欢迎消息
        setTimeout(() => {
            showPopup('开始游戏');
        }, 300);
        
        // 完全移除加载屏幕
        setTimeout(() => {
            if (loadingScreen) {
                loadingScreen.style.display = 'none';
            }
        }, 500);
    }, 1000); // 1秒后显示游戏（可根据实际加载时间调整）
});
